package com.sixth.system.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.sixth.core.entity.User;
import com.sixth.core.vo.R;
import com.sixth.system.mapper.UserMapper;
import com.sixth.system.service.UserService;
import com.sixth.system.vo.PostDataVo;
import com.sixth.system.vo.UserVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * @program: sixth-hospital-parent
 * @description:
 * @author: 李劲锋
 * @create: 2024-08-12 17:17
 **/
@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserMapper userMapper;

    @Autowired
    private PasswordEncoder passwordEncoder; // 通过依赖注入获取
    @Override
    /**
     * 根据用户名查询用户信息
     * 此方法主要用于根据用户的一个唯一标识（如手机号）来查询该用户的信息
     * 它通过构造一个查询包装器（QueryWrapper），设置查询条件，然后调用用户映射器（userMapper）的查询方法来完成查询操作
     * @param username 用户的唯一标识，如手机号
     * @return 返回一个泛型结果对象R，其中包含查询到的用户信息，如果查询不到，则可能返回空对象或特定的错误信息
     */
    public R<User> selectByName(String username) {
        // 构造查询包装器
        QueryWrapper<User> wrapper=new QueryWrapper<>();
        // 设置查询条件：手机号等于提供的用户名
        wrapper.eq("phone",username);
        // 设置查询条件：删除标志为0（通常表示未删除）
        wrapper.eq("del_flag",0);
        // 设置查询条件：用户状态为0（通常表示未激活或未启用）
        wrapper.eq("status",0);
        // 执行查询操作，获取查询结果
        User user = userMapper.selectOne(wrapper);
        if(user==null){
            return R.error("账号或密码错误");
        }
        return R.ok(user);
    }
    @Override
    public R<IPage<User>> selectByPage(UserVo userVo) {
        System.out.println("userVo "+userVo);
        //创建一个分页对象
        IPage<User> page=new Page<>(userVo.getPageNum(), userVo.getPageSize());
        // 创建一个查询对象
        QueryWrapper<User> wrapper=new QueryWrapper<>();
        if(userVo.getDeptId()!=null){
            wrapper.eq("dept_id",userVo.getDeptId());
        }
        if(StringUtils.hasText(userVo.getUsername())){
            wrapper.like("user_name",userVo.getUsername());
        }
        if(StringUtils.hasText(userVo.getPhone())){
            wrapper.like("phone",userVo.getPhone());
        }
        if(userVo.getStatus()!=null){
            wrapper.eq("status",userVo.getStatus());
        }
        if(userVo.getDateRange()!=null&&userVo.getDateRange().size()==2){
            wrapper.between("create_time",userVo.getDateRange().get(0),userVo.getDateRange().get(1));
        }
        wrapper.eq("del_flag",0);
        IPage<User> userIPage = userMapper.selectPage(page, wrapper);

        return R.ok(userIPage);
    }

    @Override
    /**
     * 批量删除用户
     * @param userIds 用户ID数组，用于指定需要删除的用户
     * @return R 删除操作的结果
     */
    public R batchDelete(Long[] userIds) {
        // 将用户ID数组转换为User对象列表，设置删除标记
        List<User> collect = Arrays.stream(userIds).map(item -> {
            User user = new User();
            user.setUserId(item);
            user.setDelFlag("1"); // 设置删除标记为1，表示已删除
            return user;
        }).collect(Collectors.toList());
        // 更新用户状态为已删除
        userMapper.updateById(collect);
        // 返回操作结果，表示删除成功
        return R.ok();
    }

    @Override
    public R add(User user) {
        //添加创建时间字段，格式为yyyy-MM-dd HH:mm:ss
        user.setCreateTime(new java.util.Date());
        user.setPicture("https://z-77.oss-cn-guangzhou.aliyuncs.com/%E7%A5%9E%E5%8C%BB/3.jpg");
        user.setPassword("$2a$10$cI7e7bgSs9.9nNHhxKO9LuK/Ll.AeZwgUyZb77oD2y3UwwZyZhWG6");
        boolean result = userMapper.insert(user) > 0;
        return R.ok(result);
    }

    @Override
    public R<User> getUserById(Long id) {
        return R.ok(userMapper.selectById(id));
    }

    @Override
    public R updateById(User user) {
        return R.ok(userMapper.updateById(user));
    }

    @Override
    public R removeById(Long userId) {
        User u=new User();
        u.setUserId(userId);
        u.setDelFlag("1"); // 设置删除标记为1，表示已删除
        return R.ok(userMapper.updateById(u));
    }
//根据用户ID更新密码
@Override
public R updatePasswordById(PostDataVo postDataVo) {
    // 创建查询条件
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.eq("user_id", postDataVo.getUserId());
    // 从数据库中获取用户
    User user = userMapper.selectOne(wrapper);
    System.out.println(user.getUserId());
    if (user == null) {
        return R.error("用户不存在");
    }
    // 加密新密码
    String encryptedPassword = passwordEncoder.encode(postDataVo.getPassword());

    // 设置新密码
    user.setPassword(encryptedPassword);

    // 更新用户信息
    int result = userMapper.updateById(user);
    if (result > 0) {
        return R.ok("密码更新成功");
    } else {
        return R.error("密码更新失败");
    }
}


    @Override
    public R<List<User>> selelctSchedulingUser(Map<String, Object> params) {
        QueryWrapper<User> wrapper=new QueryWrapper<>();
        wrapper.eq("scheduling_flag",0);
        if(Objects.nonNull(params.get("userId"))){
            wrapper.eq("user_id",params.get("userId"));
        }
        if(Objects.nonNull(params.get("deptId"))){
            wrapper.eq("dept_id",params.get("deptId"));
        }
        List<User> users = userMapper.selectList(wrapper);
        return R.ok(users);
    }

    @Override
    public R<List<User>> listAllUser() {
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.eq("scheduling_flag",0);
        return R.ok(userMapper.selectList(wrapper));
    }

    @Override
    public R<User> selectBytel(String phone) {
        return R.ok(userMapper.selectOne(new QueryWrapper<User>().eq("phone",phone)));
    }
}
